home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / SNNSV32.ZIP / SNNSv3.2 / kernel / sources / kr_td.c < prev    next >
C/C++ Source or Header  |  1994-04-25  |  25KB  |  747 lines
  1. /*****************************************************************************
  2.   FILE           : kr_td.c
  3.   SHORTNAME      : 
  4.   SNNS VERSION   : 3.2
  5.  
  6.   PURPOSE        : SNNS-Kernel Learning Functions for Time Delay networks
  7.   NOTES          : with following learning functions:
  8.                    - Backpropagation
  9.  
  10.   AUTHOR         : Oliver Schnabel, Guenter Mamier
  11.   DATE           : 
  12.  
  13.   CHANGED BY     : Michael Vogt, Guenter Mamier
  14.   IDENTIFICATION : @(#)kr_td.c    1.8 4/12/94
  15.   SCCS VERSION   : 1.8
  16.   LAST CHANGE    : 4/12/94
  17.  
  18.              Copyright (c) 1990-1994  SNNS Group, IPVR, Univ. Stuttgart, FRG
  19.  
  20. ******************************************************************************/
  21.  
  22. #include <stdio.h>
  23. #include <math.h>
  24. #include <values.h>
  25.  
  26.  
  27. #include "kr_typ.h"     /*  Kernel Types and Constants  */
  28. #include "kr_const.h"     /*  Constant Declarators for SNNS-Kernel  */
  29. #include "kr_def.h"     /*  Default Values  */
  30. #include "kernel.h"     /*  kernel function prototypes  */
  31. #include "kr_mac.h"     /*  Kernel Macros   */
  32. #include "kr_newpattern.h"
  33.  
  34. #include "kr_td.ph"
  35.  
  36.  
  37.  
  38. /*****************************************************************************
  39.   FUNCTION : initializeTDBackprop
  40.  
  41.   PURPOSE  : initialize the learning algorithm TD-backprop
  42.   NOTES    :
  43.  
  44.   RETURNS  :
  45.   UPDATE   : 19.02.1993 
  46. ******************************************************************************/
  47. static krui_err initializeTDBackprop(void)
  48. {
  49.   register FlagWord      flags;
  50.   register struct Link   *link_ptr;
  51.   register struct Unit   *unit_ptr;
  52.   register struct Site   *site_ptr; 
  53.  
  54.   /*  set unit's bias to zero  */
  55.   FOR_ALL_UNITS( unit_ptr ){
  56.       flags = unit_ptr->flags;
  57.  
  58.       if ( (unit_ptr->flags & UFLAG_IN_USE) == UFLAG_IN_USE){
  59.       if (flags & UFLAG_SITES){ /*  unit has sites  */
  60.           FOR_ALL_SITES_AND_LINKS( unit_ptr, site_ptr, link_ptr )
  61.           link_ptr->value_b = 
  62.               link_ptr->value_c = 
  63.               unit_ptr->value_a = 
  64.                   unit_ptr->value_b = 
  65.                   unit_ptr->value_c = (FlintType) 0;
  66.       }else{        /* TD-units have no sites: direct links */
  67.           if (flags & UFLAG_DLINKS){ /*  unit has direct links */
  68.           FOR_ALL_LINKS( unit_ptr, link_ptr ) 
  69.               link_ptr->value_b = 
  70.               link_ptr->value_c = 
  71.                   unit_ptr->value_a = 
  72.                   unit_ptr->value_b = 
  73.                       unit_ptr->value_c = (FlintType) 0;
  74.           }
  75.       } /* else */
  76.       } /* if */
  77.   } /* FOR_ALL_UNITS */
  78.   return( KRERR_NO_ERROR );
  79. }
  80.  
  81.  
  82. /*****************************************************************************
  83.   FUNCTION : propagateTDNetForward
  84.  
  85.   PURPOSE  : topological TimeDelay forward propagation
  86.   NOTES    : needs only the weight matrix of one receptive field for 
  87.          propagating one pattern through the net
  88.          If the provided pattern_no is < 0, no pattern is loaded into
  89.              the input layer but all other layers are propagated as usual
  90.   RETURNS  :
  91.   UPDATE   : 19.02.1993
  92. ******************************************************************************/
  93. void  propagateTDNetForward(int pattern_no, int sub_pat_no)
  94. { 
  95.   register struct Unit    *unit_ptr;
  96.   register struct Link    *link_ptr;
  97.   register Patterns       in_pat;
  98.   register TopoPtrArray   topo_ptr;
  99.   int                     i;
  100.  
  101.   if (pattern_no >= 0){
  102.       /*  calculate startaddress for input pattern array  */
  103.  
  104.       in_pat = kr_getSubPatData(pattern_no,sub_pat_no,INPUT,NULL);
  105.       topo_ptr = topo_ptr_array;
  106.  
  107.       /* copy pattern into input unit's activation and calculate output of the 
  108.      input units. */
  109.       /* order of the topoptrarray: input-, hidden- and then outputunits */    
  110.  
  111.       unit_ptr = *++topo_ptr;
  112.       while (unit_ptr != (struct Unit *) NULL){
  113.       /*  topo_ptr points to a (topological sorted) unit stucture 
  114.           (input units first)  */
  115.  
  116.       if (unit_ptr->out_func == OUT_IDENTITY){
  117.           /*  identity output function: don't call the output function  */
  118.           unit_ptr->Out.output = unit_ptr->act = *in_pat++;
  119.       }else{
  120.           /*  no identity output function: calculate unit's output also  */
  121.           unit_ptr->Out.output = 
  122.           (*unit_ptr->out_func) (unit_ptr->act = *in_pat++);
  123.       } /*if*/
  124.       unit_ptr = *++topo_ptr;
  125.       }
  126.   }else{
  127.       /* set unit_ptr and topo_ptr as if an input pattern was provided */
  128.       topo_ptr = topo_ptr_array;
  129.       unit_ptr = *++topo_ptr;
  130.       while (unit_ptr != (struct Unit *) NULL)
  131.       {
  132.       unit_ptr = *++topo_ptr;
  133.       }
  134.   }
  135.       
  136.   /* Propagate input to hidden, hidden to hidden and hidden to output */
  137.  
  138.   for (i=0; i<2; i++){
  139.       unit_ptr = *++topo_ptr;
  140.       while (unit_ptr != NULL){
  141.       /*  initialization for propagating hidden units  */
  142.       /*  clear error values */
  143.       unit_ptr->Aux.flint_no = 0.0;
  144.  
  145.       if (UNIT_HAS_DIRECT_INPUTS(unit_ptr)){
  146.           /* this is a reference unit, initialize link weight change */
  147.           /* and counter of link usage */
  148.           FOR_ALL_LINKS(unit_ptr, link_ptr){
  149.           link_ptr->value_b = link_ptr->value_c = 0.0;
  150.           }
  151.       }
  152.  
  153.       /* reset bias-change and td-step-counter before each lerning epoch */
  154.       unit_ptr->value_b = unit_ptr->value_c = 0.0;
  155.  
  156.       unit_ptr->act = (*unit_ptr->act_func) (unit_ptr);
  157.       if (unit_ptr->out_func == OUT_IDENTITY){
  158.           /*  identity output function: don't call the output function  */
  159.           unit_ptr->Out.output = unit_ptr->act;
  160.       }else{
  161.           /*  no identity output function: calculate unit's output also  */
  162.           unit_ptr->Out.output = (*unit_ptr->out_func) (unit_ptr->act);
  163.       }      
  164.       unit_ptr = *++topo_ptr;
  165.       }
  166.   }
  167. } /*endfunction*/
  168.  
  169.  
  170.  
  171. /*****************************************************************************
  172.   FUNCTION : propagateTDNetBackward
  173.  
  174.   PURPOSE  : Time Delay Backward error propagation (topological).
  175.   NOTES    : Start calculating the average of the corresponding links in 
  176.              all TD-steps. This average is used to update the links of the 
  177.          1st. receptive field.
  178.   RETURNS  : network error
  179.   UPDATE   : 19.02.1993
  180. ******************************************************************************/
  181. static    float propagateTDNetBackward(int pattern_no, int sub_pat_no,
  182.                      float learn_parameter, 
  183.                      float delta_max)
  184. { 
  185.     register struct Link   *link_ptr;
  186.     register struct Site   *site_ptr;
  187.     register struct Unit   *unit_ptr, *unit_ptr1 ;
  188.     register struct Unit   *ref_unit;
  189.     register Patterns      out_pat;
  190.     register float         error,  sum_error,  eta,  devit, learn_error;
  191.     register TopoPtrArray  topo_ptr;
  192.     int                    last_log_layer, i;
  193.     int                    size;
  194.  
  195.     sum_error = 0.0;        /*  reset network error  */
  196.     eta = learn_parameter;    /*  store learn_parameter in CPU register  */
  197.  
  198.     /*  calculate address of the output pattern (with number pattern_no + 1) */
  199.  
  200.     topo_ptr = topo_ptr_array + (no_of_topo_units + 2);
  201.     last_log_layer = (*topo_ptr)->lln;
  202.     out_pat = kr_getSubPatData(pattern_no,sub_pat_no,OUTPUT,&size);
  203.     out_pat += size;
  204.  
  205.     /* calculate output units only: begin at the end of topo_pointer_array */
  206.     unit_ptr = *topo_ptr;
  207.     while (unit_ptr != (struct Unit *) NULL){
  208.     devit = *(--out_pat) - unit_ptr->Out.output; /*  calc. devitation */
  209.  
  210.     if ( (float) fabs( devit ) <= delta_max ){
  211.         unit_ptr = *--topo_ptr;
  212.         continue;
  213.     }
  214.  
  215.     sum_error += devit * devit; /*  sum up the error of the network  */
  216.  
  217.     /* calculate error for output units     */
  218.     /* output layer cannot have time delay structure, so no 
  219.        distinction is necessary*/
  220.     error = devit * (unit_ptr->act_deriv_func) ( unit_ptr ); 
  221.  
  222.     /* calc. the error for adjusting weights and bias of pred. units  */
  223.     learn_error = eta * error; 
  224.  
  225.     /* adjust bias value  */
  226.     unit_ptr->value_b += learn_error;
  227.     unit_ptr->value_c += 1.0;
  228.  
  229.     if (UNIT_HAS_DIRECT_INPUTS( unit_ptr )){ /* the unit has direkt links */
  230.         /* error must be saved for each unit of the hiddenlayer */
  231.         FOR_ALL_LINKS( unit_ptr, link_ptr ){
  232.         /* adjust link weights and calc. sum of errors of pred. units*/
  233.         link_ptr->to->Aux.flint_no += link_ptr->weight * error;
  234.         link_ptr->value_b += learn_error * link_ptr->to->Out.output;
  235.         link_ptr->value_c += 1.0;
  236.         }
  237.     }else{ /* the unit has sites: not necessary for TD-Network  */
  238.         FOR_ALL_SITES_AND_LINKS( unit_ptr, site_ptr, link_ptr ){
  239.         /* adjust link weights and calc. sum of errors of pred. units */
  240.         link_ptr->to->Aux.flint_no += link_ptr->weight * error;
  241.         link_ptr->weight += learn_error * link_ptr->to->Out.output;
  242.             }
  243.     }
  244.      
  245.     unit_ptr = *--topo_ptr; 
  246.     } /* while */
  247.  
  248.  
  249.     /*  calculate hidden units only. add the weight changes of all receptive 
  250.     fields ; stored for every linkin the Linkstructure value_c of only the 
  251.     first recept. field! 
  252.     */
  253.   
  254.     unit_ptr = *--topo_ptr;
  255.     while (unit_ptr != (struct Unit *) NULL){
  256.     /* calc. the error of the hidden units */
  257.     error = (unit_ptr->act_deriv_func) (unit_ptr) * unit_ptr->Aux.flint_no;
  258.     
  259.     /* calc. the error for adjusting weights and bias of pred. units */
  260.     learn_error = eta * error;
  261.  
  262.  
  263.     if (unit_ptr->TD.td_connect_typ == 1){
  264.         /* this is a time delay connection type layer */
  265.  
  266.         ref_unit = *(unit_ptr->TD.my_topo_ptr + unit_ptr->TD.target_offset);
  267.         /*    adjust bias value  */
  268.         ref_unit->value_b += learn_error;
  269.         ref_unit->value_c += 1.0;
  270.     
  271.         if (UNIT_HAS_DIRECT_INPUTS( ref_unit )){
  272.         /*  the unit has direkt links    */
  273.         
  274.         FOR_ALL_LINKS( ref_unit, link_ptr ) {
  275.             /* adjust link weights and calc. sum of err of pred. units*/
  276.             /* unit_ptr1 points to the actual predecessor unit, 
  277.                determined by the actual link */
  278.             unit_ptr1 = *(link_ptr->to->TD.my_topo_ptr 
  279.                   + unit_ptr->TD.source_offset);
  280.         
  281.             if (IS_HIDDEN_UNIT (unit_ptr1)) {
  282.             /* this unit is a hidden unit: add the error from 
  283.                previous units dependent on type of this predecessor 
  284.                unit   */
  285.             (unit_ptr1)->Aux.flint_no += link_ptr->weight * error;
  286.             }
  287.             /* immediately updating the links cannot fit for TD 
  288.                Networks! Add the the delta(ij) of all td_steps in the 
  289.                Linkarray(value_c) of the first recept. field  */
  290.             link_ptr->value_b += learn_error * (unit_ptr1)->Out.output;
  291.             link_ptr->value_c += 1.0;
  292.         }
  293.         }
  294.     }else{
  295.         /* fully connected layers */
  296.         /* immediately update of all physical links */
  297.         unit_ptr->bias += learn_error;
  298.  
  299.         if (UNIT_HAS_DIRECT_INPUTS( unit_ptr )){
  300.         /*  the unit has direkt links  */
  301.         /* error must be saved for each unit of the hiddenlayer */
  302.         FOR_ALL_LINKS( unit_ptr, link_ptr ){
  303.             /* adjust link weights and calc. sum of err of pred units*/
  304.             if (IS_HIDDEN_UNIT (link_ptr->to))
  305.             link_ptr->to->Aux.flint_no += link_ptr->weight * error;
  306.           
  307.             link_ptr->weight += learn_error * link_ptr->to->Out.output;
  308.         }
  309.         }else{ /* the unit has sites: not necessary for TD-Network  */
  310.         FOR_ALL_SITES_AND_LINKS( unit_ptr, site_ptr, link_ptr ){
  311.             /*  adjust link weights and calc. sum of errors of the 
  312.             predecessor units */
  313.             if (IS_HIDDEN_UNIT (link_ptr->to)) 
  314.             link_ptr->to->Aux.flint_no += link_ptr->weight * error;
  315.             link_ptr->weight += learn_error * link_ptr->to->Out.output;
  316.         }
  317.         }
  318.     }
  319.     unit_ptr = *--topo_ptr;
  320.     } /* while */
  321.   
  322.  
  323.     /* update receptive fields: propagate and calculate all featureunits of 
  324.        the first td-step of each layer.   */
  325.     /* topo_ptr points to the NULL pointer between input and hidden units */
  326.  
  327.     for (i=0; i<2; i++){
  328.     unit_ptr = *++topo_ptr;
  329.     while (unit_ptr != NULL){
  330.         if (unit_ptr->TD.td_connect_typ==1 && 
  331.         UNIT_HAS_DIRECT_INPUTS(unit_ptr)){
  332.         /* this is a reference unit of a time delay layer */
  333.  
  334.         /* update bias of reference unit by average bias change */
  335.         unit_ptr->bias += unit_ptr->value_b / unit_ptr->value_c;
  336.  
  337.         FOR_ALL_LINKS( unit_ptr, link_ptr ){ 
  338.             /* store average linkweigth changes of all Td-steps */
  339.             link_ptr->weight += link_ptr->value_b / link_ptr->value_c;
  340.         } /*for_all_links*/
  341.         }
  342.         unit_ptr = *++topo_ptr;
  343.     }
  344.     }
  345.     return( sum_error );    /*  return the error of the network */
  346. }
  347.  
  348.  
  349.  
  350. /*****************************************************************************
  351.   FUNCTION : LEARN_TDbackprop
  352.  
  353.   PURPOSE  : Time Delay Backpropagation Learning Function
  354.   NOTES    : Input Parameters:   1 : learning parameter
  355.                                  2 : delta max
  356.  
  357.              Output Parameters:  1 : error of the network (sum of all cycles)
  358.  
  359.   RETURNS  :
  360.   UPDATE   : 19.02.1993
  361. ******************************************************************************/
  362. krui_err  LEARN_TDbackprop( int start_pattern, int end_pattern, 
  363.                float parameterInArray[], int NoOfInParams,
  364.                float * *parameterOutArray, int *NoOfOutParams )
  365.  
  366. {
  367.     static  float  OutParameter[1]; /* OutParameter[0] stores learning error */
  368.     int   i, ret_code, pattern_no, sub_pat_no;
  369.     int   j;
  370.     struct Unit *unit_ptr;
  371.  
  372.     if (NoOfUnits == 0)  
  373.     return( KRERR_NO_UNITS ); /*  No Units defined    */
  374.     if (NoOfInParams < 1)    /*  #  has to be changed (must be 2) # */
  375.     return( KRERR_PARAMETERS ); /*  Not enough input parameters  */
  376.  
  377.     *NoOfOutParams = 1;     /* One return value is available (the learning error)*/
  378.     *parameterOutArray = OutParameter; /* set the output parameter reference  */
  379.     ret_code = KRERR_NO_ERROR;  /*  reset return code  */
  380.  
  381.     if (NetModified || (TopoSortID != TOPOLOGIC_LOGICAL)){
  382.     /*  Net has been modified or topologic array isn't initialized */
  383.     /*  check the topology of the network  */
  384.     /* first: save the logical layer numbers, restore them after check */
  385.     FOR_ALL_UNITS(unit_ptr)
  386.         unit_ptr -> Aux.int_no = unit_ptr -> lln;
  387.     ret_code = kr_topoCheck();
  388.  
  389.     FOR_ALL_UNITS(unit_ptr)
  390.         unit_ptr -> lln = unit_ptr -> Aux.int_no;
  391.     if (ret_code < KRERR_NO_ERROR)  
  392.         return( ret_code );    /*  an error has occured  */
  393.     if (ret_code < 2)  
  394.         return( KRERR_NET_DEPTH ); /* the network has less then 2 layers */
  395.  
  396.     /*    count the no. of I/O units and check the patterns  */
  397.     ret_code = kr_IOCheck();
  398.     if (ret_code < KRERR_NO_ERROR)  
  399.         return( ret_code );
  400.  
  401.     ret_code = kr_topoSort( TOPOLOGIC_LOGICAL );
  402.     if ((ret_code != KRERR_NO_ERROR) && (ret_code != KRERR_DEAD_UNITS))
  403.         return( ret_code );
  404.  
  405. #ifdef DEBUG
  406.     /* M.V. */
  407.     j=1;
  408.     while (krui_setCurrentUnit(j) == KRERR_NO_ERROR) {
  409.         printf("Unit %d: lln = %d, lun = %d\n",j,
  410.            kr_getUnitPtr(j) -> lln, kr_getUnitPtr(j) -> lun);
  411.         j++;
  412.     }
  413. #endif
  414.  
  415.     NetModified = FALSE;
  416.     }
  417.  
  418.     if (NetInitialize || LearnFuncHasChanged){
  419.     /*  Net has been modified or initialized, initialize TDbackprop now */
  420.     ret_code = initializeTDBackprop();
  421.     if (ret_code != KRERR_NO_ERROR)  
  422.         return( ret_code );
  423.     }
  424.  
  425.  
  426.     /* compute the necessary sub patterns */
  427.  
  428.     KernelErrorCode = kr_initSubPatternOrder(start_pattern,end_pattern);
  429.     if(KernelErrorCode != KRERR_NO_ERROR)
  430.     return (KernelErrorCode);
  431.  
  432.  
  433.     NET_ERROR(OutParameter) = 0.0;    /* reset network error value  */
  434.  
  435.     while(kr_getSubPatternByOrder(&pattern_no,&sub_pat_no)){
  436.  
  437.     propagateTDNetForward(pattern_no,sub_pat_no); /* Forward propagation */
  438.  
  439.     /*  Backward propagation  */
  440.     /*  1st parameter is the learning parameter
  441.         2nd parameter is the max. devitation between output pattern and
  442.         the output of the output unit (delta max)
  443.         */
  444.     NET_ERROR( OutParameter ) +=
  445.         propagateTDNetBackward(pattern_no,sub_pat_no,
  446.                    LEARN_PARAM1( parameterInArray ),
  447.                    LEARN_PARAM2( parameterInArray ) );
  448.     }
  449.  
  450.     return( ret_code );
  451. }
  452.  
  453.  
  454.  
  455. /*****************************************************************************
  456.   FUNCTION : LEARN_TDBP_McClelland
  457.  
  458.   PURPOSE  : Time Delay Backpropagation Learning Function With McClelland
  459.              Error function: E = sum(log(1-(oi-ti)^2))
  460.  
  461.   NOTES    : Input Parameters:   1 : learning parameter
  462.                                  2 : delta max
  463.  
  464.              Output Parameters:  1 : error of the network (sum of all cycles)
  465.  
  466.   RETURNS  :
  467.   UPDATE   : 19.02.1993
  468. ******************************************************************************/
  469. krui_err  LEARN_TDBP_McClelland( int start_pattern, int end_pattern, 
  470.                 float parameterInArray[], int NoOfInParams,
  471.                 float * *parameterOutArray, int *NoOfOutParams )
  472.  
  473. {
  474.     static  float  OutParameter[1]; /* OutParameter[0] stores learning error*/
  475.     int   i, ret_code, pattern_no, sub_pat_no;
  476.     int   j;
  477.     struct Unit *unit_ptr;
  478.  
  479.     if (NoOfUnits == 0)  
  480.     return( KRERR_NO_UNITS ); /*  No Units defined    */
  481.     if (NoOfInParams < 1)    /*  #  has to be changed (must be 2) # */
  482.     return( KRERR_PARAMETERS ); /*  Not enough input parameters  */
  483.  
  484.     *NoOfOutParams = 1;    /* One return value is available (the learning error)*/
  485.     *parameterOutArray = OutParameter; /* set the output parameter reference */
  486.     ret_code = KRERR_NO_ERROR;  /*  reset return code  */
  487.  
  488.     if (NetModified || (TopoSortID != TOPOLOGIC_LOGICAL)){
  489.     /*  Net has been modified or topologic array isn't initialized */
  490.     /*  check the topology of the network  */
  491.     /* first: save the logical layer numbers, restore them after check */
  492.     FOR_ALL_UNITS(unit_ptr)
  493.         unit_ptr -> Aux.int_no = unit_ptr -> lln;
  494.     ret_code = kr_topoCheck();
  495.  
  496.     FOR_ALL_UNITS(unit_ptr)
  497.         unit_ptr -> lln = unit_ptr -> Aux.int_no;
  498.     if (ret_code < KRERR_NO_ERROR)  
  499.         return( ret_code );    /*  an error has occured  */
  500.     if (ret_code < 2)  
  501.         return( KRERR_NET_DEPTH ); /* the network has less then 2 layers */
  502.  
  503.     /* count the no. of I/O units and check the patterns  */
  504.     ret_code = kr_IOCheck();
  505.     if (ret_code < KRERR_NO_ERROR)  
  506.         return( ret_code );
  507.  
  508.     ret_code = kr_topoSort( TOPOLOGIC_LOGICAL );
  509.     if ((ret_code != KRERR_NO_ERROR) && (ret_code != KRERR_DEAD_UNITS))
  510.         return( ret_code );
  511.  
  512. #ifdef DEBUG
  513.     /* M.V. */
  514.     j=1;
  515.     while (krui_setCurrentUnit(j) == KRERR_NO_ERROR) {
  516.         printf("Unit %d: lln = %d, lun = %d\n",  j,
  517.            kr_getUnitPtr(j) -> lln, kr_getUnitPtr(j) -> lun);
  518.         j++;
  519.     }
  520. #endif
  521.  
  522.     NetModified = FALSE;
  523.     }
  524.  
  525.     if (NetInitialize || LearnFuncHasChanged){
  526.     /*  Net has been modified or initialized, initialize TDbackprop now  */
  527.     ret_code = initializeTDBackprop();
  528.     if (ret_code != KRERR_NO_ERROR)  
  529.         return( ret_code );
  530.     }
  531.  
  532.  
  533.     /* compute the necessary sub patterns */
  534.  
  535.     KernelErrorCode = kr_initSubPatternOrder(start_pattern,end_pattern);
  536.     if(KernelErrorCode != KRERR_NO_ERROR)
  537.     return (KernelErrorCode);
  538.  
  539.  
  540.     NET_ERROR(OutParameter) = 0.0;    /* reset network error value  */
  541.  
  542.     while(kr_getSubPatternByOrder(&pattern_no,&sub_pat_no)){
  543.  
  544.     propagateTDNetForward(pattern_no,sub_pat_no); /*  Forward propagation */
  545.  
  546.     /*  Backward propagation  */
  547.     /*  1st parameter is the learning parameter
  548.         2nd parameter is the max. devitation between output pattern and
  549.         the output of the output unit (delta max)
  550.         */
  551.     NET_ERROR( OutParameter ) +=
  552.         propagateTDNetBackMcClelland(pattern_no,sub_pat_no,
  553.                      LEARN_PARAM1( parameterInArray ),
  554.                      LEARN_PARAM2( parameterInArray ) );
  555.     }
  556.  
  557.     return( ret_code );
  558. }
  559.  
  560.  
  561. /*****************************************************************************
  562.   FUNCTION : propagateTDNetBackMcClelland
  563.  
  564.   PURPOSE  : Time Delay Backward error propagation (topological).
  565.   NOTES    : Start calculating the average of the corresponding links in 
  566.              all TD-steps. This average is used to update the links of the 
  567.          1st. receptive field.
  568.   RETURNS  : network error
  569.   UPDATE   : 19.02.1993
  570. ******************************************************************************/
  571. static    float propagateTDNetBackMcClelland(int pattern_no, int sub_pat_no,
  572.                        float learn_parameter,
  573.                        float delta_max)
  574. { 
  575.     register struct Link   *link_ptr;
  576.     register struct Site   *site_ptr;
  577.     register struct Unit   *unit_ptr, *unit_ptr1 ;
  578.     register struct Unit   *ref_unit;
  579.     register Patterns      out_pat;
  580.     register float         error,  sum_error,  eta,  devit, learn_error;
  581.     register TopoPtrArray  topo_ptr;
  582.     int                    last_log_layer, i;
  583.     int                    size;
  584.  
  585.  
  586.     sum_error = 0.0;        /*  reset network error  */
  587.     eta = learn_parameter;    /*  store learn_parameter in CPU register  */
  588.  
  589.     /*  calculate address of the output pattern (with number pattern_no + 1) */
  590.  
  591.     topo_ptr = topo_ptr_array + (no_of_topo_units + 2);
  592.     last_log_layer = (*topo_ptr)->lln;
  593.     out_pat = kr_getSubPatData(pattern_no,sub_pat_no,OUTPUT,&size);
  594.     out_pat += size;
  595.  
  596.     /* calculate output units only: begin at the end of topo_pointer_array */
  597.     unit_ptr = *topo_ptr;
  598.     while (unit_ptr != (struct Unit *) NULL){
  599.     devit = *(--out_pat) - unit_ptr->Out.output; /*  calc. devitation */
  600.  
  601.     if ( (float) fabs( devit ) <= delta_max ){
  602.         unit_ptr = *--topo_ptr;
  603.         continue;
  604.     }
  605.  
  606.     sum_error += -log10(1- fabs(devit)); /* sum up error of the network */
  607.  
  608.     /* calculate error for output units     */
  609.     /* output layer cannot have time delay structure, so no 
  610.        distinction is necessary*/
  611.     error = log10(1- fabs(devit)) * (unit_ptr->act_deriv_func) (unit_ptr); 
  612.     if(devit > 0) error = -error;
  613.  
  614.     /* calc. error for adjusting weights and bias of predecessor units */
  615.     learn_error = eta * error; 
  616.  
  617.     /* adjust bias value  */
  618.     unit_ptr->value_b += learn_error;
  619.     unit_ptr->value_c += 1.0;
  620.  
  621.     if (UNIT_HAS_DIRECT_INPUTS( unit_ptr )){
  622.         /*  the unit has direkt links  */
  623.         /* error must be saved for each unit of the hiddenlayer */
  624.         FOR_ALL_LINKS( unit_ptr, link_ptr ){
  625.         /* adjust link weights and calc. sum of errors of pred. units*/
  626.         link_ptr->to->Aux.flint_no += link_ptr->weight * error;
  627.         link_ptr->value_b += learn_error * link_ptr->to->Out.output;
  628.         link_ptr->value_c += 1.0;
  629.         }
  630.     }else{ /* the unit has sites: not necessary for TD-Network  */
  631.         FOR_ALL_SITES_AND_LINKS( unit_ptr, site_ptr, link_ptr ){
  632.         /* adjust link weights and calc. sum of errors of 
  633.            predecessor units */
  634.         link_ptr->to->Aux.flint_no += link_ptr->weight * error;
  635.         link_ptr->weight += learn_error * link_ptr->to->Out.output;
  636.             }
  637.     }
  638.      
  639.     unit_ptr = *--topo_ptr; 
  640.     } /* while */
  641.  
  642.  
  643.     /*  calculate hidden units only. add the weightchanges of all receptive 
  644.     fields ; stored for every link in the Linkstructure value_c of only 
  645.     the first recept. field! 
  646.     */
  647.   
  648.     unit_ptr = *--topo_ptr;
  649.     while (unit_ptr != (struct Unit *) NULL){
  650.     /* calc. the error of the hidden units */
  651.     error = (unit_ptr->act_deriv_func) (unit_ptr) * unit_ptr->Aux.flint_no;
  652.     
  653.     /* calc. error for adjusting weights and bias of predecessor units */
  654.     learn_error = eta * error;
  655.  
  656.  
  657.     if (unit_ptr->TD.td_connect_typ == 1){
  658.         /* this is a time delay connection type layer */
  659.  
  660.         ref_unit = *(unit_ptr->TD.my_topo_ptr + unit_ptr->TD.target_offset);
  661.         /*    adjust bias value  */
  662.         ref_unit->value_b += learn_error;
  663.         ref_unit->value_c += 1.0;
  664.     
  665.         if (UNIT_HAS_DIRECT_INPUTS( ref_unit )){
  666.         /*  the unit has direkt links    */
  667.         
  668.         FOR_ALL_LINKS( ref_unit, link_ptr ){
  669.             /* adjust link weights and calc. sum of err of pred. units*/
  670.             /* unit_ptr1 points to the actual predecessor unit, 
  671.                determined by the actual link */
  672.             unit_ptr1 = *(link_ptr->to->TD.my_topo_ptr 
  673.                   + unit_ptr->TD.source_offset);
  674.         
  675.             if (IS_HIDDEN_UNIT (unit_ptr1)){
  676.             /* this unit is a hidden unit: add the error from 
  677.                previous units dependent on type of this predecessor 
  678.                unit   */
  679.             (unit_ptr1)->Aux.flint_no += link_ptr->weight * error;
  680.             }
  681.             /* immediately updating the links cannot fit for TD 
  682.                Networks! Add the the delta(ij) of all td_steps in the 
  683.                Linkarray(value_c) of the first recept. field  */
  684.             link_ptr->value_b += learn_error * (unit_ptr1)->Out.output;
  685.             link_ptr->value_c += 1.0;
  686.         }
  687.         }
  688.     }else{
  689.         /* fully connected layers */
  690.         /* immediately update of all physical links */
  691.         unit_ptr->bias += learn_error;
  692.  
  693.         if (UNIT_HAS_DIRECT_INPUTS( unit_ptr )){
  694.         /*  the unit has direkt links  */
  695.         /* error must be saved for each unit of the hiddenlayer */
  696.         FOR_ALL_LINKS( unit_ptr, link_ptr ){
  697.             /* adjust link weights and calc. sum of 
  698.                errors of predecessor units  */
  699.             if (IS_HIDDEN_UNIT (link_ptr->to))
  700.             link_ptr->to->Aux.flint_no += link_ptr->weight * error;
  701.           
  702.             link_ptr->weight += learn_error * link_ptr->to->Out.output;
  703.         }
  704.         }else{/* the unit has sites: not necessary for TD-Network  */
  705.         FOR_ALL_SITES_AND_LINKS( unit_ptr, site_ptr, link_ptr ){
  706.             /*  adjust link weights and calc. sum of errors of the 
  707.             predecessor units */
  708.             if (IS_HIDDEN_UNIT (link_ptr->to)) 
  709.             link_ptr->to->Aux.flint_no += link_ptr->weight * error;
  710.             link_ptr->weight += learn_error * link_ptr->to->Out.output;
  711.         }
  712.         }
  713.     }
  714.     unit_ptr = *--topo_ptr;
  715.     } /* while */
  716.   
  717.  
  718.     /* update receptive fields: propagate and calculate all featureunits of 
  719.        the first td-step of each layer.   */
  720.     /* topo_ptr points to the NULL pointer between input and hidden units */
  721.  
  722.     for (i=0; i<2; i++){
  723.     unit_ptr = *++topo_ptr;
  724.     while (unit_ptr != NULL){
  725.         if (unit_ptr->TD.td_connect_typ==1 && 
  726.         UNIT_HAS_DIRECT_INPUTS(unit_ptr)){
  727.         /* this is a reference unit of a time delay layer */
  728.  
  729.         /* update bias of reference unit by average bias change */
  730.         unit_ptr->bias += unit_ptr->value_b / unit_ptr->value_c;
  731.  
  732.         FOR_ALL_LINKS( unit_ptr, link_ptr ){ 
  733.             /* store average linkweigth changes of all Td-steps */
  734.             link_ptr->weight += link_ptr->value_b / link_ptr->value_c;
  735.         } /*for_all_links*/
  736.         }
  737.         unit_ptr = *++topo_ptr;
  738.     }
  739.     }
  740.     return( sum_error );/*  return the error of the network */
  741. }
  742.  
  743.  
  744.  
  745.  
  746.  
  747.